import pytest  # used for our unit tests
from workload import AlexNet

# unit tests

# 1. BASIC TEST CASES

def test_single_sublist_basic():
    # Single sublist with positive integers
    model = AlexNet()
    x = [[1, 2, 3, 4, 5]]
    # sum=15, mean=3, min=1, max=5, len=5
    expected = [[15, 3.0, 1, 5, 5]]
    codeflash_output = model._extract_features(x) # 1.25μs -> 340ns (268% faster)

def test_multiple_sublists_basic():
    # Multiple sublists with varied content
    model = AlexNet()
    x = [[1, 2, 3], [10, 20], [5]]
    expected = [
        [6, 2.0, 1, 3, 3],
        [30, 15.0, 10, 20, 2],
        [5, 5.0, 5, 5, 1]
    ]
    codeflash_output = model._extract_features(x) # 1.16μs -> 321ns (262% faster)

def test_single_empty_sublist():
    # Single empty sublist
    model = AlexNet()
    x = [[]]
    expected = [[0, 0, 0, 0, 0]]
    codeflash_output = model._extract_features(x) # 1.14μs -> 331ns (245% faster)

def test_empty_x():
    # x is empty list
    model = AlexNet()
    x = []
    expected = []
    codeflash_output = model._extract_features(x) # 851ns -> 320ns (166% faster)

def test_floats_and_ints():
    # Sublist with floats and ints
    model = AlexNet()
    x = [[1.5, 2, 3.5]]
    # sum=7.0, mean=2.333..., min=1.5, max=3.5, len=3
    expected = [[7.0, 7.0/3, 1.5, 3.5, 3]]
    codeflash_output = model._extract_features(x); out = codeflash_output # 1.20μs -> 310ns (288% faster)

# 2. EDGE TEST CASES

def test_sublist_with_negative_numbers():
    # Sublist with negative and positive numbers
    model = AlexNet()
    x = [[-10, 0, 10]]
    expected = [[0, 0.0, -10, 10, 3]]
    codeflash_output = model._extract_features(x) # 1.08μs -> 320ns (238% faster)

def test_sublist_with_all_zeros():
    # Sublist with all zeros
    model = AlexNet()
    x = [[0, 0, 0]]
    expected = [[0, 0.0, 0, 0, 3]]
    codeflash_output = model._extract_features(x) # 1.10μs -> 311ns (254% faster)

def test_sublist_with_large_numbers():
    # Sublist with very large numbers
    model = AlexNet()
    x = [[1e10, 2e10, 3e10]]
    expected = [[6e10, 2e10, 1e10, 3e10, 3]]
    codeflash_output = model._extract_features(x); out = codeflash_output # 1.11μs -> 320ns (248% faster)

def test_sublist_with_single_element():
    # Sublist with a single element
    model = AlexNet()
    x = [[42]]
    expected = [[42, 42.0, 42, 42, 1]]
    codeflash_output = model._extract_features(x) # 1.13μs -> 300ns (277% faster)



def test_sublist_with_nan_inf():
    # Sublist contains float('nan') and float('inf')
    import math
    model = AlexNet()
    x = [[1, float('nan'), 3]]
    # nan in min/max/mean/sum will propagate
    codeflash_output = model._extract_features(x); out = codeflash_output # 1.36μs -> 440ns (210% faster)

    x2 = [[1, float('inf'), 3]]
    codeflash_output = model._extract_features(x2); out2 = codeflash_output # 441ns -> 170ns (159% faster)




def test_sublist_with_bool():
    # Sublist contains booleans (should be accepted as int subclass)
    model = AlexNet()
    x = [[True, False, 1]]
    # True==1, False==0
    expected = [[2, 2/3, 0, 1, 3]]
    codeflash_output = model._extract_features(x); out = codeflash_output # 1.41μs -> 451ns (213% faster)

# 3. LARGE SCALE TEST CASES

def test_large_number_of_sublists():
    # Many sublists, each with a single element
    model = AlexNet()
    n = 1000
    x = [[i] for i in range(n)]
    expected = [[i, float(i), i, i, 1] for i in range(n)]
    codeflash_output = model._extract_features(x); out = codeflash_output # 15.8μs -> 450ns (3411% faster)

def test_large_sublists():
    # One sublist with many elements
    model = AlexNet()
    n = 1000
    x = [list(range(n))]
    s = sum(range(n))
    mn = 0
    mx = n - 1
    mean = s / n
    expected = [[s, mean, mn, mx, n]]
    codeflash_output = model._extract_features(x); out = codeflash_output # 942ns -> 370ns (155% faster)

def test_many_large_sublists():
    # Many sublists, each with many elements
    model = AlexNet()
    n = 100  # 100 sublists
    m = 100  # each with 100 elements
    x = [list(range(i, i+m)) for i in range(n)]
    codeflash_output = model._extract_features(x); out = codeflash_output # 1.74μs -> 371ns (370% faster)
    for i in range(n):
        sub = list(range(i, i+m))
        s = sum(sub)
        mean = s / m
        mn = i
        mx = i + m - 1
        l = m
        expected_stats = [s, mean, mn, mx, l]
        for j in range(5):
            pass

def test_large_empty_sublists():
    # Many empty sublists
    model = AlexNet()
    n = 1000
    x = [[] for _ in range(n)]
    expected = [[0, 0, 0, 0, 0] for _ in range(n)]
    codeflash_output = model._extract_features(x) # 16.0μs -> 420ns (3712% faster)

def test_large_mix_of_empty_and_nonempty():
    # Alternating empty and non-empty sublists
    model = AlexNet()
    n = 1000
    x = [[i] if i % 2 == 0 else [] for i in range(n)]
    codeflash_output = model._extract_features(x); out = codeflash_output # 15.9μs -> 430ns (3588% faster)
    for i in range(n):
        if i % 2 == 0:
            pass
        else:
            pass
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import pytest  # used for our unit tests
from workload import AlexNet

# unit tests

# 1. Basic Test Cases

def test_single_sample_positive_numbers():
    # Test with a single sample, all positive numbers
    model = AlexNet()
    x = [[1, 2, 3]]
    codeflash_output = model._extract_features(x) # 1.22μs -> 401ns (205% faster)

def test_single_sample_negative_numbers():
    # Test with a single sample, all negative numbers
    model = AlexNet()
    x = [[-1, -2, -3]]
    codeflash_output = model._extract_features(x) # 1.09μs -> 360ns (203% faster)

def test_single_sample_mixed_numbers():
    # Test with a single sample, mixed positive and negative numbers
    model = AlexNet()
    x = [[-1, 2, -3, 4]]
    codeflash_output = model._extract_features(x) # 1.14μs -> 341ns (235% faster)

def test_multiple_samples():
    # Test with multiple samples
    model = AlexNet()
    x = [[1, -1], [2, 2], [-3, 3]]
    codeflash_output = model._extract_features(x) # 1.14μs -> 371ns (208% faster)

def test_sample_with_zeroes():
    # Test with a sample containing zeroes
    model = AlexNet()
    x = [[0, 0, 1, -1]]
    codeflash_output = model._extract_features(x) # 1.10μs -> 351ns (214% faster)

def test_empty_sample_in_list():
    # Test with an empty sample in the list
    model = AlexNet()
    x = [[1, 2], []]
    codeflash_output = model._extract_features(x) # 1.15μs -> 310ns (272% faster)

def test_all_empty_samples():
    # Test with all empty samples
    model = AlexNet()
    x = [[], [], []]
    codeflash_output = model._extract_features(x) # 1.09μs -> 341ns (221% faster)

# 2. Edge Test Cases

def test_empty_input_list():
    # Test with an empty input list
    model = AlexNet()
    x = []
    codeflash_output = model._extract_features(x) # 861ns -> 320ns (169% faster)




def test_large_negative_and_positive():
    # Test with very large positive and negative numbers
    model = AlexNet()
    x = [[-1e12, 1e12], [1e20, -1e20]]
    codeflash_output = model._extract_features(x) # 1.39μs -> 461ns (202% faster)

def test_float_features():
    # Test with float features
    model = AlexNet()
    x = [[-1.5, 2.5, -3.0]]
    codeflash_output = model._extract_features(x) # 1.23μs -> 361ns (241% faster)

def test_tuple_samples():
    # Test with tuple samples
    model = AlexNet()
    x = [(1, -2, 3)]
    codeflash_output = model._extract_features(x) # 1.18μs -> 370ns (219% faster)

def test_tuple_features():
    # Test with tuple features inside a list
    model = AlexNet()
    x = [[1, 2], (3, -4)]
    codeflash_output = model._extract_features(x) # 1.17μs -> 340ns (245% faster)

# 3. Large Scale Test Cases

def test_large_number_of_samples():
    # Test with a large number of samples (1000)
    model = AlexNet()
    x = [[i, -i] for i in range(1000)]  # Each sample sums to 2*abs(i)
    expected = [2*abs(i) for i in range(1000)]
    codeflash_output = model._extract_features(x) # 15.7μs -> 440ns (3472% faster)

def test_large_number_of_features_per_sample():
    # Test with one sample, many features (1000)
    model = AlexNet()
    x = [list(range(-500, 500))]  # Features: -500 to 499
    # Sum of abs(-500) + abs(-499) + ... + abs(499)
    expected = sum(abs(i) for i in range(-500, 500))
    codeflash_output = model._extract_features(x) # 962ns -> 371ns (159% faster)

def test_large_samples_and_large_features():
    # Test with 500 samples, each with 500 features
    model = AlexNet()
    x = [list(range(i, i+500)) for i in range(500)]
    expected = [sum(abs(j) for j in range(i, i+500)) for i in range(500)]
    codeflash_output = model._extract_features(x) # 7.63μs -> 671ns (1038% faster)

def test_performance_with_maximum_allowed():
    # Test with 1000 samples, each with 1000 features (all ones)
    model = AlexNet()
    x = [[1]*1000 for _ in range(1000)]
    expected = [1000]*1000
    codeflash_output = model._extract_features(x) # 15.7μs -> 592ns (2559% faster)

# Additional edge case: features are all zero
def test_all_zero_features():
    model = AlexNet()
    x = [[0]*10 for _ in range(5)]
    codeflash_output = model._extract_features(x) # 892ns -> 351ns (154% faster)

# Additional edge case: input is list of tuples and lists mixed
def test_mixed_tuple_and_list_samples():
    model = AlexNet()
    x = [[1, -2, 3], (4, -5, 6)]
    codeflash_output = model._extract_features(x) # 1.15μs -> 350ns (229% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.